1. Field of the Invention
The present invention relates to the fields of distributed computing systems, client-server computing and object oriented programming. Specifically, the present invention is a method and apparatus comprising logic modules, called a client-side stub generator and a client-side stub interpreter, that have been designed to minimize the memory space required by client-side stubs.
2. Background
A key problem in Operating Systems development and maintenance is permitting the introduction of new interfaces and implementation techniques in a way which allows clients and programmers maximum flexibility without loading the operating system down with implementation details. Moreover, this problem becomes more intense when developing object oriented operating systems which have micro-kernel architectures. Micro-kernels typically permit clients to implement complex sub-systems at the client level, such as file systems, for example. Nevertheless, basic system processes such as interclient or intercomputer communications are so complex that clients and object implementors should not be concerned with these processes. That is, these inherently "system" type processes are more efficiently done by standard modules, but should be handled in a way which does not require that the base operating system is constrained by these processes.
As a part of the solution to this basic problem for systems which use the object metaphor to define the interfaces between different components of a system, stubs and other similar types of intermediate logic modules have been used. Such stubs are described as standard modules to handle communications of object calls between remote computers which may be sending other objects as parameters of the calls. These stubs and other similar modules and their relationship to each other are described more fully below within the context of the detailed description of this invention comprising the stub generator and stub interpreter.
In an object oriented system, an object is a component comprising data and operations which can be invoked to manipulate the data. The operations are invoked on the object by sending calls to the object. Each object has an object type. The object type defines the operations that can be performed on objects of that type. The object operations are implemented independent of the objects themselves. Additionally, one object type may inherit the object operations defined and implemented for other object types. For further description of object oriented design and programming techniques see "Object-oriented Software Construction" by Bertrand Meyer, Prentice-Hall 1988.
In client-server computing, typically there is a set of computers that can communicate with one another through a network connecting the computers. Some of these computers act as providers of services or functionality to other computers. The providers of such service or functionality are known as "servers", and the consumers of such service or functionality are called "clients". The client-server model also generalizes to the case where distinct programs running on the same computer are communicating with one another through some protected mechanism and are acting as providers and consumers of functionality.
In object oriented distributed systems based upon the client-server model, there exist servers that provide object oriented interfaces to their clients. These servers support objects consisting of data and the associated software. Clients may obtain access to these objects and may execute calls on them. These calls are transmitted to the server from the client. At the server these calls are executed via the software associated with the object. The results of these calls are then transmitted back to the client.
In more modern systems, the application software does not talk directly to the network software. Instead the application software talks to "stubs" (14 in FIG. 1). The stubs provide a consistent interface to the clients whether there is a network between the client and server or not. There is a distinct stub for each distinct interface that is supported by the system. The stub code is responsible for converting between a specific language-level interface seen by application level software and the standard low-level communication interfaces provided by the network software. For example, the stubs are responsible for taking the arguments to a remote call and putting them into a message suitable for the network software to transmit over the network. Such uses of stubs are described in the section on Remote Procedure Calls ("RPC") on pages 349-368 of the book titled "Software Implementation Techniques" by Donald E. Merusi, Digital Press 1992, ISBN 1-55558-090-4.
Because of the number of client-side stubs which are generated in such object oriented, distributed systems it has become clear that a mechanism is needed to reduce the text memory space occupied by the code related to these many client-side stubs.
Accordingly, the present invention provides an apparatus and a method comprising logic modules, called a client-side stub generator, a database of compressed client-side stub execution code and a client-side stub interpreter, that have been designed to minimize the memory space required by client-side stubs while retaining the design of stubs to provide control of the basic mechanisms of object invocation and argument passing that are most important in distributed systems, and which permits the application programmers to be unaware of the specific stubs that are being used for particular objects.